/**
 * API调用模块
 */
import { API_BASE_URL, DEFAULT_PID, DEFAULT_HOSPITAL_ID, getOrgId } from './config.js';
import { state } from './state.js';
import { renderProfessionTabs, updateContentArea } from './ui.js';

/**
 * 获取标签列表
 * @param {string} pid - 父级ID，如果为空则获取根级数据
 */
export const getTagList = async (pid = null) => {
  try {
    const params = new URLSearchParams();
    
    // 如果没有传入pid，根据URL参数决定使用哪个值
    if (!pid) {
      const urlParams = new URLSearchParams(window.location.search);
      const orgCode = urlParams.get('orgCode');
      
      if (orgCode) {
        // 如果URL参数有orgCode，调用getOrgId获取组织ID
        console.log('检测到orgCode参数，正在获取组织ID...');
        const orgId = await getOrgId();
        if (orgId && orgId !== '0') {
          pid = orgId;
          console.log('获取到组织ID:', orgId);
        } else {
          // 如果获取失败，使用默认值
          pid = DEFAULT_PID;
          console.log('获取组织ID失败，使用默认PID:', DEFAULT_PID);
        }
      } else {
        // 如果没有orgCode参数，使用默认值
        pid = DEFAULT_PID;
        console.log('未检测到orgCode参数，使用默认PID:', DEFAULT_PID);
      }
    }
    
    params.append('pid', pid);
    
    const url = `${API_BASE_URL}/sys/sysDepart/queryDepartTreeSync?${params.toString()}`;
    console.log('请求URL:', url);
    
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
      },
      credentials: 'include'
    });
    
    const res = await response.json();
    console.log('API响应:', res);
    
    // 处理响应数据：优先使用 result 字段
    if (res.success && res.result && Array.isArray(res.result)) {
      return res.result;
    } else if (res.success && Array.isArray(res.success)) {
      return res.success;
    } else if (res.success && res.success.records && Array.isArray(res.success.records)) {
      return res.success.records;
    } else {
      return [];
    }
  } catch (error) {
    console.error('获取标签列表失败:', error);
    return [];
  }
};

/**
 * 获取职业类型列表
 * @param {string} hospitalId - 医院ID，如果为空则从URL参数id获取，否则使用默认值
 */
export const getProfessionList = async (hospitalId = null) => {
  try {
    state.professionLoading = true;
    
    // 如果没有传入hospitalId，从URL参数中获取id
    if (!hospitalId) {
      const urlParams = new URLSearchParams(window.location.search);
      const urlId = urlParams.get('id');
      
      if (urlId) {
        hospitalId = urlId;
        console.log('从URL参数获取到hospitalId:', hospitalId);
      } else {
        hospitalId = DEFAULT_HOSPITAL_ID;
        console.log('未检测到URL参数id，使用默认hospitalId:', hospitalId);
      }
    }
    
    console.log('获取职业类型列表, hospitalId:', hospitalId);
    
    const params = new URLSearchParams({
      hospitalId: hospitalId,
      _t: Date.now().toString()
    });
    
    const url = `${API_BASE_URL}/job_visible/jobVisible/list?${params.toString()}`;
    console.log('请求职业类型URL:', url);
    
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
      },
      credentials: 'include'
    });
    
    const res = await response.json();
    console.log('职业类型响应:', res);
    
    if (res.success && res.result && res.result.records && res.result.records.length > 0) {
      // 解析 mode_dictText 字段（逗号分隔的字符串）
      const modeDictText = res.result.records[0].mode_dictText;
      if (modeDictText) {
        state.professionList = modeDictText.split(',').map(item => item.trim()).filter(item => item);
        console.log('职业类型列表:', state.professionList);
      } else {
        // 如果没有 mode_dictText，使用默认值
        state.professionList = ['医生', '护士', '康复师', '技师'];
        console.warn('未找到 mode_dictText，使用默认职业类型');
      }
    } else if (res.success && Array.isArray(res.result)) {
      // 如果直接是数组格式
      const firstRecord = res.result[0];
      if (firstRecord && firstRecord.mode_dictText) {
        state.professionList = firstRecord.mode_dictText.split(',').map(item => item.trim()).filter(item => item);
      } else {
        state.professionList = ['医生', '护士', '康复师', '技师'];
      }
    } else {
      // 如果接口返回空，使用默认的职业列表
      state.professionList = ['医生', '护士', '康复师', '技师'];
      console.warn('职业类型接口返回空，使用默认职业类型');
    }
  } catch (error) {
    console.error('获取职业类型列表失败:', error);
    // 使用默认的职业列表作为备选
    state.professionList = ['医生', '护士', '康复师', '技师'];
  } finally {
    state.professionLoading = false;
    // 更新职业类型Tab显示
    renderProfessionTabs();
  }
};

/**
 * 获取护士列表
 * @param {string} projectId - 项目ID（三级目录项ID）
 */
export const getNurseList = async (projectId) => {
  if (!projectId) {
    state.nurseList = [];
    updateContentArea();
    return;
  }
  
  // 如果职业列表为空，等待加载完成
  if (state.professionList.length === 0 && state.professionLoading) {
    console.log('职业列表正在加载，等待加载完成...');
    // 等待最多3秒
    let waitCount = 0;
    while (state.professionLoading && waitCount < 30) {
      await new Promise(resolve => setTimeout(resolve, 100));
      waitCount++;
    }
  }
  
  // 如果职业列表仍然为空，使用默认值
  if (state.professionList.length === 0) {
    console.warn('职业列表为空，使用默认职业类型');
    state.professionList = ['医生', '护士', '康复师', '技师'];
  }
  
  try {
    state.nurseLoading = true;
    const job = state.professionList[state.selectedProfessionIndex] || state.professionList[0];
    console.log('获取护士列表, projectId:', projectId, 'job:', job);
    
    const params = new URLSearchParams({
      pageSize: '12',
      pageNo: '1',
      projectid: projectId,
      job: job,
      status: '1',
      tagId: projectId,
      _t: Date.now().toString()
    });
    
    const url = `${API_BASE_URL}/nurse_nurses/nurseNurses/list?${params.toString()}`;
    console.log('请求护士列表URL:', url);
    
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
      },
      credentials: 'include'
    });
    
    const res = await response.json();
    console.log('护士列表响应:', res);
    
    if (res.success && res.result && res.result.records) {
      state.nurseList = res.result.records || [];
    } else if (res.success && Array.isArray(res.result)) {
      state.nurseList = res.result;
    } else {
      state.nurseList = [];
    }
  } catch (error) {
    console.error('获取护士列表失败:', error);
    state.nurseList = [];
  } finally {
    state.nurseLoading = false;
    updateContentArea();
  }
};

